/******************************************************************************
 *  _____     _____
 *  \  __\    \  __\
 *   \ \_\\    \ \_\\
 *    \  __\SS  \  __\roject
 *     \_\       \_\
 *
 * Mateusz Maciąg, Rafał Urbański
 * Komputerowe Systemy Sterowania
 *****************************************************************************/

#include "ARXPreset.h"

namespace RafMat
{
namespace UI
{

using namespace std;

std::vector<ARXPresetSPtr> ARXPreset::m_presets;

ARXPreset::ARXPreset(string presetName, string objName,
                     string numerator, string denominator, string SDnumerator,
                     string delay, string swTime,
                     int minADegree, int minBDegree, int minCDegree , int minAgDegree, int minD,int minDelay
                     )
    : m_numerator(numerator), m_denominator(denominator), m_SDnumerator(SDnumerator), m_delay(delay),
      m_switchTime(swTime), m_objName(objName), m_presetName(presetName),
      m_minADegree(minADegree), m_minBDegree(minBDegree),m_minCDegree(minCDegree), m_minAgDegree(minAgDegree), m_minD(minD), m_minDelay(minDelay)
{

}

const std::vector<ARXPresetSPtr>& ARXPreset::presets()
{
    if(m_presets.size() == 0)
        initPresets();

    return m_presets;
}

void ARXPreset::initPresets()
{

    //Presety nie dzialaja wiec nie dopisywalem Ag i d

    // Układ inercyjny I rzędu (filtr DP IIR)
    m_presets.push_back(ARXPresetSPtr(
                            new ARXPreset("GPCTEST", "LP1",
                                          "[400 600]", "[1000 -800]","[0]",
                                          "1", "-1",
                                          1, 1, 0, 0, 0, 1
                                          )));

    // Układ blokujący sygnał
    m_presets.push_back(ARXPresetSPtr(
                            new ARXPreset("Non-observable", "Blocking",
                                          "[0]", "[1000000000]","[0]",
                                          "0", "-1",
                                          0, 0, 0,0,0,0)));

    // Układ całkujący
    m_presets.push_back(ARXPresetSPtr(
                            new ARXPreset("Integral", "Integral",
                                          "[100]", "[1000 -1000]","[0]",
                                          "0", "-1",
                                          1, 0, 0,0,0, 0)));

    // Układ różniczkujący idealny
    m_presets.push_back(ARXPresetSPtr(
                            new ARXPreset("Ideal derivative", "Derivative",
                                          "[1000 -1000]", "[-1000]","[0]",
                                          "0", "-1",
                                          0, 1, 0,0,0, 0)));

    // Układ różniczkujący rzeczywisty
    m_presets.push_back(ARXPresetSPtr(
                            new ARXPreset("Real derivative", "Derivative",
                                          "[1000 -1000]", "[2000 -900]","[0]",
                                          "0", "-1",
                                          1, 1,0,0,0, 0
                                          )));

    // Układ opóźniający
    m_presets.push_back(ARXPresetSPtr(
                            new ARXPreset("Transport delay", "Delay",
                                          "[1000]", "[1000]","[0]",
                                          "50", "-1",
                                          0, 0, 0 , 0,0,50
                                          )));

    // Układ inercyjny I rzędu (filtr DP IIR)
    m_presets.push_back(ARXPresetSPtr(
                            new ARXPreset("First-order IIR low pass filter", "LP1",
                                          "[0 6.7]", "[100 -90]","[0]",
                                          "0", "-1",
                                          1, 1, 0, 0,0,0
                                          )));

    // Układ inercyjny I rzędu z opóźnieniem
    m_presets.push_back(ARXPresetSPtr(
                            new ARXPreset("Low pass with delay", "LP1-Delayed",
                                          "[0 5]", "[100 -95]","[0]",
                                          "25", "-1",
                                          1, 1, 0, 0,0, 25
                                          )));

    // Filtr FIR - średnia ruchoma
    m_presets.push_back(ARXPresetSPtr(
                            new ARXPreset("Moving average", "FIR-MovingAvg",
                                          "[111 111 111 111 111 111 111 111 111]", "[1000]","[0]",
                                          "0", "-1",
                                          0, 8,0,0,0, 0
                                          )));

    // Układ nieminimalnofazowy z opóźnieniem
    m_presets.push_back(ARXPresetSPtr(
                            new ARXPreset("Non-minimal phase oscillator", "Osc-ph",
                                          "[-70 0 -100]", "[1000 -1880 900]","[0]",
                                          "0", "-1",
                                          2, 2, 0,0,0, 0
                                          )));

    // Układ na granicy stabilności
    m_presets.push_back(ARXPresetSPtr(
                            new ARXPreset("Stable oscillator", "Osc",
                                          "[0 0 10]", "[1000 -1880 1000]","[0]",
                                          "0", "-1",
                                          2, 2, 0, 0,0,0
                                          )));
}

}
}
